home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / mapping_tests.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  26KB  |  870 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import unittest
  5. import UserDict
  6.  
  7. class BasicTestMappingProtocol(unittest.TestCase):
  8.     type2test = None
  9.     
  10.     def _reference(self):
  11.         '''Return a dictionary of values which are invariant by storage
  12.         in the object under test.'''
  13.         return {
  14.             1: 2,
  15.             'key1': 'value1',
  16.             'key2': (1, 2, 3) }
  17.  
  18.     
  19.     def _empty_mapping(self):
  20.         '''Return an empty mapping object'''
  21.         return self.type2test()
  22.  
  23.     
  24.     def _full_mapping(self, data):
  25.         '''Return a mapping object with the value contained in data
  26.         dictionary'''
  27.         x = self._empty_mapping()
  28.         for key, value in data.items():
  29.             x[key] = value
  30.         
  31.         return x
  32.  
  33.     
  34.     def __init__(self, *args, **kw):
  35.         unittest.TestCase.__init__(self, *args, **kw)
  36.         self.reference = self._reference().copy()
  37.         (key, value) = self.reference.popitem()
  38.         self.other = {
  39.             key: value }
  40.         (key, value) = self.reference.popitem()
  41.         self.inmapping = {
  42.             key: value }
  43.         self.reference[key] = value
  44.  
  45.     
  46.     def test_read(self):
  47.         p = self._empty_mapping()
  48.         p1 = dict(p)
  49.         d = self._full_mapping(self.reference)
  50.         if d is p:
  51.             p = p1
  52.         
  53.         for key, value in self.reference.items():
  54.             self.assertEqual(d[key], value)
  55.         
  56.         knownkey = self.other.keys()[0]
  57.         self.failUnlessRaises(KeyError, (lambda : d[knownkey]))
  58.         self.assertEqual(len(p), 0)
  59.         self.assertEqual(len(d), len(self.reference))
  60.         for k in self.reference:
  61.             self.assert_(d.has_key(k))
  62.             self.assert_(k in d)
  63.         
  64.         for k in self.other:
  65.             self.failIf(d.has_key(k))
  66.             self.failIf(k in d)
  67.         
  68.         self.assertEqual(cmp(p, p), 0)
  69.         self.assertEqual(cmp(d, d), 0)
  70.         self.assertEqual(cmp(p, d), -1)
  71.         self.assertEqual(cmp(d, p), 1)
  72.         if p:
  73.             self.fail('Empty mapping must compare to False')
  74.         
  75.         if not d:
  76.             self.fail('Full mapping must compare to True')
  77.         
  78.         
  79.         def check_iterandlist(iter, lst, ref):
  80.             self.assert_(hasattr(iter, 'next'))
  81.             self.assert_(hasattr(iter, '__iter__'))
  82.             x = list(iter)
  83.             None(self.assert_ if set(lst) == set(lst) else set(lst) == set(ref))
  84.  
  85.         check_iterandlist(d.iterkeys(), d.keys(), self.reference.keys())
  86.         check_iterandlist(iter(d), d.keys(), self.reference.keys())
  87.         check_iterandlist(d.itervalues(), d.values(), self.reference.values())
  88.         check_iterandlist(d.iteritems(), d.items(), self.reference.items())
  89.         (key, value) = d.iteritems().next()
  90.         (knownkey, knownvalue) = self.other.iteritems().next()
  91.         self.assertEqual(d.get(key, knownvalue), value)
  92.         self.assertEqual(d.get(knownkey, knownvalue), knownvalue)
  93.         self.failIf(knownkey in d)
  94.  
  95.     
  96.     def test_write(self):
  97.         p = self._empty_mapping()
  98.         for key, value in self.reference.items():
  99.             p[key] = value
  100.             self.assertEqual(p[key], value)
  101.         
  102.         for None in self.reference.keys():
  103.             key = None
  104.             del p[key]
  105.         
  106.         p = self._empty_mapping()
  107.         p.update(self.reference)
  108.         self.assertEqual(dict(p), self.reference)
  109.         items = p.items()
  110.         p = self._empty_mapping()
  111.         p.update(items)
  112.         self.assertEqual(dict(p), self.reference)
  113.         d = self._full_mapping(self.reference)
  114.         (key, value) = d.iteritems().next()
  115.         (knownkey, knownvalue) = self.other.iteritems().next()
  116.         self.assertEqual(d.setdefault(key, knownvalue), value)
  117.         self.assertEqual(d[key], value)
  118.         self.assertEqual(d.setdefault(knownkey, knownvalue), knownvalue)
  119.         self.assertEqual(d[knownkey], knownvalue)
  120.         self.assertEqual(d.pop(knownkey), knownvalue)
  121.         self.failIf(knownkey in d)
  122.         self.assertRaises(KeyError, d.pop, knownkey)
  123.         default = 909
  124.         d[knownkey] = knownvalue
  125.         self.assertEqual(d.pop(knownkey, default), knownvalue)
  126.         self.failIf(knownkey in d)
  127.         self.assertEqual(d.pop(knownkey, default), default)
  128.         (key, value) = d.popitem()
  129.         self.failIf(key in d)
  130.         self.assertEqual(value, self.reference[key])
  131.         p = self._empty_mapping()
  132.         self.assertRaises(KeyError, p.popitem)
  133.  
  134.     
  135.     def test_constructor(self):
  136.         self.assertEqual(self._empty_mapping(), self._empty_mapping())
  137.  
  138.     
  139.     def test_bool(self):
  140.         self.assert_(not self._empty_mapping())
  141.         self.assert_(self.reference)
  142.         self.assert_(bool(self._empty_mapping()) is False)
  143.         self.assert_(bool(self.reference) is True)
  144.  
  145.     
  146.     def test_keys(self):
  147.         d = self._empty_mapping()
  148.         self.assertEqual(d.keys(), [])
  149.         d = self.reference
  150.         self.assert_(self.inmapping.keys()[0] in d.keys())
  151.         self.assert_(self.other.keys()[0] not in d.keys())
  152.         self.assertRaises(TypeError, d.keys, None)
  153.  
  154.     
  155.     def test_values(self):
  156.         d = self._empty_mapping()
  157.         self.assertEqual(d.values(), [])
  158.         self.assertRaises(TypeError, d.values, None)
  159.  
  160.     
  161.     def test_items(self):
  162.         d = self._empty_mapping()
  163.         self.assertEqual(d.items(), [])
  164.         self.assertRaises(TypeError, d.items, None)
  165.  
  166.     
  167.     def test_len(self):
  168.         d = self._empty_mapping()
  169.         self.assertEqual(len(d), 0)
  170.  
  171.     
  172.     def test_getitem(self):
  173.         d = self.reference
  174.         self.assertEqual(d[self.inmapping.keys()[0]], self.inmapping.values()[0])
  175.         self.assertRaises(TypeError, d.__getitem__)
  176.  
  177.     
  178.     def test_update(self):
  179.         d = self._empty_mapping()
  180.         d.update(self.other)
  181.         self.assertEqual(d.items(), self.other.items())
  182.         d = self._empty_mapping()
  183.         d.update()
  184.         self.assertEqual(d, self._empty_mapping())
  185.         d = self._empty_mapping()
  186.         d.update(self.other.items())
  187.         self.assertEqual(d.items(), self.other.items())
  188.         d = self._empty_mapping()
  189.         d.update(self.other.iteritems())
  190.         self.assertEqual(d.items(), self.other.items())
  191.         self.assertRaises((TypeError, AttributeError), d.update, 42)
  192.         outerself = self
  193.         
  194.         class SimpleUserDict:
  195.             
  196.             def __init__(self):
  197.                 self.d = outerself.reference
  198.  
  199.             
  200.             def keys(self):
  201.                 return self.d.keys()
  202.  
  203.             
  204.             def __getitem__(self, i):
  205.                 return self.d[i]
  206.  
  207.  
  208.         d.clear()
  209.         d.update(SimpleUserDict())
  210.         i1 = d.items()
  211.         i2 = self.reference.items()
  212.         i1.sort()
  213.         i2.sort()
  214.         self.assertEqual(i1, i2)
  215.         
  216.         class Exc(Exception):
  217.             pass
  218.  
  219.         d = self._empty_mapping()
  220.         
  221.         class FailingUserDict:
  222.             
  223.             def keys(self):
  224.                 raise Exc
  225.  
  226.  
  227.         self.assertRaises(Exc, d.update, FailingUserDict())
  228.         d.clear()
  229.         
  230.         class FailingUserDict:
  231.             
  232.             def keys(self):
  233.                 
  234.                 class BogonIter:
  235.                     
  236.                     def __init__(self):
  237.                         self.i = 1
  238.  
  239.                     
  240.                     def __iter__(self):
  241.                         return self
  242.  
  243.                     
  244.                     def next(self):
  245.                         if self.i:
  246.                             self.i = 0
  247.                             return 'a'
  248.                         
  249.                         raise Exc
  250.  
  251.  
  252.                 return BogonIter()
  253.  
  254.             
  255.             def __getitem__(self, key):
  256.                 return key
  257.  
  258.  
  259.         self.assertRaises(Exc, d.update, FailingUserDict())
  260.         
  261.         class FailingUserDict:
  262.             
  263.             def keys(self):
  264.                 
  265.                 class BogonIter:
  266.                     
  267.                     def __init__(self):
  268.                         self.i = ord('a')
  269.  
  270.                     
  271.                     def __iter__(self):
  272.                         return self
  273.  
  274.                     
  275.                     def next(self):
  276.                         if self.i <= ord('z'):
  277.                             rtn = chr(self.i)
  278.                             self.i += 1
  279.                             return rtn
  280.                         
  281.                         raise StopIteration
  282.  
  283.  
  284.                 return BogonIter()
  285.  
  286.             
  287.             def __getitem__(self, key):
  288.                 raise Exc
  289.  
  290.  
  291.         self.assertRaises(Exc, d.update, FailingUserDict())
  292.         d = self._empty_mapping()
  293.         
  294.         class badseq(object):
  295.             
  296.             def __iter__(self):
  297.                 return self
  298.  
  299.             
  300.             def next(self):
  301.                 raise Exc()
  302.  
  303.  
  304.         self.assertRaises(Exc, d.update, badseq())
  305.         self.assertRaises(ValueError, d.update, [
  306.             (1, 2, 3)])
  307.  
  308.     
  309.     def test_get(self):
  310.         d = self._empty_mapping()
  311.         self.assert_(d.get(self.other.keys()[0]) is None)
  312.         self.assertEqual(d.get(self.other.keys()[0], 3), 3)
  313.         d = self.reference
  314.         self.assert_(d.get(self.other.keys()[0]) is None)
  315.         self.assertEqual(d.get(self.other.keys()[0], 3), 3)
  316.         self.assertEqual(d.get(self.inmapping.keys()[0]), self.inmapping.values()[0])
  317.         self.assertEqual(d.get(self.inmapping.keys()[0], 3), self.inmapping.values()[0])
  318.         self.assertRaises(TypeError, d.get)
  319.         self.assertRaises(TypeError, d.get, None, None, None)
  320.  
  321.     
  322.     def test_setdefault(self):
  323.         d = self._empty_mapping()
  324.         self.assertRaises(TypeError, d.setdefault)
  325.  
  326.     
  327.     def test_popitem(self):
  328.         d = self._empty_mapping()
  329.         self.assertRaises(KeyError, d.popitem)
  330.         self.assertRaises(TypeError, d.popitem, 42)
  331.  
  332.     
  333.     def test_pop(self):
  334.         d = self._empty_mapping()
  335.         (k, v) = self.inmapping.items()[0]
  336.         d[k] = v
  337.         self.assertRaises(KeyError, d.pop, self.other.keys()[0])
  338.         self.assertEqual(d.pop(k), v)
  339.         self.assertEqual(len(d), 0)
  340.         self.assertRaises(KeyError, d.pop, k)
  341.  
  342.  
  343.  
  344. class TestMappingProtocol(BasicTestMappingProtocol):
  345.     
  346.     def test_constructor(self):
  347.         BasicTestMappingProtocol.test_constructor(self)
  348.         self.assert_(self._empty_mapping() is not self._empty_mapping())
  349.         self.assertEqual(self.type2test(x = 1, y = 2), {
  350.             'x': 1,
  351.             'y': 2 })
  352.  
  353.     
  354.     def test_bool(self):
  355.         BasicTestMappingProtocol.test_bool(self)
  356.         self.assert_(not self._empty_mapping())
  357.         self.assert_(self._full_mapping({
  358.             'x': 'y' }))
  359.         self.assert_(bool(self._empty_mapping()) is False)
  360.         self.assert_(bool(self._full_mapping({
  361.             'x': 'y' })) is True)
  362.  
  363.     
  364.     def test_keys(self):
  365.         BasicTestMappingProtocol.test_keys(self)
  366.         d = self._empty_mapping()
  367.         self.assertEqual(d.keys(), [])
  368.         d = self._full_mapping({
  369.             'a': 1,
  370.             'b': 2 })
  371.         k = d.keys()
  372.         self.assert_('a' in k)
  373.         self.assert_('b' in k)
  374.         self.assert_('c' not in k)
  375.  
  376.     
  377.     def test_values(self):
  378.         BasicTestMappingProtocol.test_values(self)
  379.         d = self._full_mapping({
  380.             1: 2 })
  381.         self.assertEqual(d.values(), [
  382.             2])
  383.  
  384.     
  385.     def test_items(self):
  386.         BasicTestMappingProtocol.test_items(self)
  387.         d = self._full_mapping({
  388.             1: 2 })
  389.         self.assertEqual(d.items(), [
  390.             (1, 2)])
  391.  
  392.     
  393.     def test_has_key(self):
  394.         d = self._empty_mapping()
  395.         self.assert_(not d.has_key('a'))
  396.         d = self._full_mapping({
  397.             'a': 1,
  398.             'b': 2 })
  399.         k = d.keys()
  400.         k.sort()
  401.         self.assertEqual(k, [
  402.             'a',
  403.             'b'])
  404.         self.assertRaises(TypeError, d.has_key)
  405.  
  406.     
  407.     def test_contains(self):
  408.         d = self._empty_mapping()
  409.         self.assert_('a' not in d)
  410.         self.assert_('a' not in d)
  411.         d = self._full_mapping({
  412.             'a': 1,
  413.             'b': 2 })
  414.         self.assert_('a' in d)
  415.         self.assert_('b' in d)
  416.         self.assert_('c' not in d)
  417.         self.assertRaises(TypeError, d.__contains__)
  418.  
  419.     
  420.     def test_len(self):
  421.         BasicTestMappingProtocol.test_len(self)
  422.         d = self._full_mapping({
  423.             'a': 1,
  424.             'b': 2 })
  425.         self.assertEqual(len(d), 2)
  426.  
  427.     
  428.     def test_getitem(self):
  429.         BasicTestMappingProtocol.test_getitem(self)
  430.         d = self._full_mapping({
  431.             'a': 1,
  432.             'b': 2 })
  433.         self.assertEqual(d['a'], 1)
  434.         self.assertEqual(d['b'], 2)
  435.         d['c'] = 3
  436.         d['a'] = 4
  437.         self.assertEqual(d['c'], 3)
  438.         self.assertEqual(d['a'], 4)
  439.         del d['b']
  440.         self.assertEqual(d, {
  441.             'a': 4,
  442.             'c': 3 })
  443.         self.assertRaises(TypeError, d.__getitem__)
  444.  
  445.     
  446.     def test_clear(self):
  447.         d = self._full_mapping({
  448.             1: 1,
  449.             2: 2,
  450.             3: 3 })
  451.         d.clear()
  452.         self.assertEqual(d, { })
  453.         self.assertRaises(TypeError, d.clear, None)
  454.  
  455.     
  456.     def test_update(self):
  457.         BasicTestMappingProtocol.test_update(self)
  458.         d = self._empty_mapping()
  459.         d.update({
  460.             1: 100 })
  461.         d.update({
  462.             2: 20 })
  463.         d.update({
  464.             1: 1,
  465.             2: 2,
  466.             3: 3 })
  467.         self.assertEqual(d, {
  468.             1: 1,
  469.             2: 2,
  470.             3: 3 })
  471.         d.update()
  472.         self.assertEqual(d, {
  473.             1: 1,
  474.             2: 2,
  475.             3: 3 })
  476.         d = self._empty_mapping()
  477.         d.update(x = 100)
  478.         d.update(y = 20)
  479.         d.update(x = 1, y = 2, z = 3)
  480.         self.assertEqual(d, {
  481.             'x': 1,
  482.             'y': 2,
  483.             'z': 3 })
  484.         d = self._empty_mapping()
  485.         d.update([
  486.             ('x', 100),
  487.             ('y', 20)])
  488.         self.assertEqual(d, {
  489.             'x': 100,
  490.             'y': 20 })
  491.         d = self._empty_mapping()
  492.         d.update([
  493.             ('x', 100),
  494.             ('y', 20)], x = 1, y = 2)
  495.         self.assertEqual(d, {
  496.             'x': 1,
  497.             'y': 2 })
  498.         d = self._full_mapping({
  499.             1: 3,
  500.             2: 4 })
  501.         d.update(self._full_mapping({
  502.             1: 2,
  503.             3: 4,
  504.             5: 6 }).iteritems())
  505.         self.assertEqual(d, {
  506.             1: 2,
  507.             2: 4,
  508.             3: 4,
  509.             5: 6 })
  510.         
  511.         class SimpleUserDict:
  512.             
  513.             def __init__(self):
  514.                 self.d = {
  515.                     1: 1,
  516.                     2: 2,
  517.                     3: 3 }
  518.  
  519.             
  520.             def keys(self):
  521.                 return self.d.keys()
  522.  
  523.             
  524.             def __getitem__(self, i):
  525.                 return self.d[i]
  526.  
  527.  
  528.         d.clear()
  529.         d.update(SimpleUserDict())
  530.         self.assertEqual(d, {
  531.             1: 1,
  532.             2: 2,
  533.             3: 3 })
  534.  
  535.     
  536.     def test_fromkeys(self):
  537.         self.assertEqual(self.type2test.fromkeys('abc'), {
  538.             'a': None,
  539.             'b': None,
  540.             'c': None })
  541.         d = self._empty_mapping()
  542.         self.assert_(d.fromkeys('abc') is not d)
  543.         self.assertEqual(d.fromkeys('abc'), {
  544.             'a': None,
  545.             'b': None,
  546.             'c': None })
  547.         self.assertEqual(d.fromkeys((4, 5), 0), {
  548.             4: 0,
  549.             5: 0 })
  550.         self.assertEqual(d.fromkeys([]), { })
  551.         
  552.         def g():
  553.             yield 1
  554.  
  555.         self.assertEqual(d.fromkeys(g()), {
  556.             1: None })
  557.         self.assertRaises(TypeError, { }.fromkeys, 3)
  558.         
  559.         class dictlike(self.type2test):
  560.             pass
  561.  
  562.         self.assertEqual(dictlike.fromkeys('a'), {
  563.             'a': None })
  564.         self.assertEqual(dictlike().fromkeys('a'), {
  565.             'a': None })
  566.         self.assert_(dictlike.fromkeys('a').__class__ is dictlike)
  567.         self.assert_(dictlike().fromkeys('a').__class__ is dictlike)
  568.         
  569.         class mydict(self.type2test):
  570.             
  571.             def __new__(cls):
  572.                 return UserDict.UserDict()
  573.  
  574.  
  575.         ud = mydict.fromkeys('ab')
  576.         self.assertEqual(ud, {
  577.             'a': None,
  578.             'b': None })
  579.         self.assertRaises(TypeError, dict.fromkeys)
  580.         
  581.         class Exc(Exception):
  582.             pass
  583.  
  584.         
  585.         class baddict1(self.type2test):
  586.             
  587.             def __init__(self):
  588.                 raise Exc()
  589.  
  590.  
  591.         self.assertRaises(Exc, baddict1.fromkeys, [
  592.             1])
  593.         
  594.         class BadSeq(object):
  595.             
  596.             def __iter__(self):
  597.                 return self
  598.  
  599.             
  600.             def next(self):
  601.                 raise Exc()
  602.  
  603.  
  604.         self.assertRaises(Exc, self.type2test.fromkeys, BadSeq())
  605.         
  606.         class baddict2(self.type2test):
  607.             
  608.             def __setitem__(self, key, value):
  609.                 raise Exc()
  610.  
  611.  
  612.         self.assertRaises(Exc, baddict2.fromkeys, [
  613.             1])
  614.  
  615.     
  616.     def test_copy(self):
  617.         d = self._full_mapping({
  618.             1: 1,
  619.             2: 2,
  620.             3: 3 })
  621.         self.assertEqual(d.copy(), {
  622.             1: 1,
  623.             2: 2,
  624.             3: 3 })
  625.         d = self._empty_mapping()
  626.         self.assertEqual(d.copy(), d)
  627.         self.assert_(isinstance(d.copy(), d.__class__))
  628.         self.assertRaises(TypeError, d.copy, None)
  629.  
  630.     
  631.     def test_get(self):
  632.         BasicTestMappingProtocol.test_get(self)
  633.         d = self._empty_mapping()
  634.         self.assert_(d.get('c') is None)
  635.         self.assertEqual(d.get('c', 3), 3)
  636.         d = self._full_mapping({
  637.             'a': 1,
  638.             'b': 2 })
  639.         self.assert_(d.get('c') is None)
  640.         self.assertEqual(d.get('c', 3), 3)
  641.         self.assertEqual(d.get('a'), 1)
  642.         self.assertEqual(d.get('a', 3), 1)
  643.  
  644.     
  645.     def test_setdefault(self):
  646.         BasicTestMappingProtocol.test_setdefault(self)
  647.         d = self._empty_mapping()
  648.         self.assert_(d.setdefault('key0') is None)
  649.         d.setdefault('key0', [])
  650.         self.assert_(d.setdefault('key0') is None)
  651.         d.setdefault('key', []).append(3)
  652.         self.assertEqual(d['key'][0], 3)
  653.         d.setdefault('key', []).append(4)
  654.         self.assertEqual(len(d['key']), 2)
  655.  
  656.     
  657.     def test_popitem(self):
  658.         BasicTestMappingProtocol.test_popitem(self)
  659.         for copymode in (-1, 1):
  660.             for log2size in range(12):
  661.                 size = 2 ** log2size
  662.                 a = self._empty_mapping()
  663.                 b = self._empty_mapping()
  664.                 for i in range(size):
  665.                     a[repr(i)] = i
  666.                     if copymode < 0:
  667.                         b[repr(i)] = i
  668.                         continue
  669.                 
  670.                 if copymode > 0:
  671.                     b = a.copy()
  672.                 
  673.                 for i in range(size):
  674.                     (ka, va) = ta = a.popitem()
  675.                     self.assertEqual(va, int(ka))
  676.                     (kb, vb) = tb = b.popitem()
  677.                     self.assertEqual(vb, int(kb))
  678.                     if copymode < 0:
  679.                         pass
  680.                     self.assert_(not (ta != tb))
  681.                 
  682.                 self.assert_(not a)
  683.                 self.assert_(not b)
  684.             
  685.         
  686.  
  687.     
  688.     def test_pop(self):
  689.         BasicTestMappingProtocol.test_pop(self)
  690.         d = self._empty_mapping()
  691.         (k, v) = ('abc', 'def')
  692.         x = 0x10000000000000L
  693.         y = 0x10000000000000L
  694.         h = self._full_mapping({
  695.             x: 'anything',
  696.             y: 'something else' })
  697.         self.assertEqual(h[x], h[y])
  698.         self.assertEqual(d.pop(k, v), v)
  699.         d[k] = v
  700.         self.assertEqual(d.pop(k, 1), v)
  701.  
  702.  
  703.  
  704. class TestHashMappingProtocol(TestMappingProtocol):
  705.     
  706.     def test_getitem(self):
  707.         TestMappingProtocol.test_getitem(self)
  708.         
  709.         class Exc(Exception):
  710.             pass
  711.  
  712.         
  713.         class BadEq(object):
  714.             
  715.             def __eq__(self, other):
  716.                 raise Exc()
  717.  
  718.  
  719.         d = self._empty_mapping()
  720.         d[BadEq()] = 42
  721.         self.assertRaises(KeyError, d.__getitem__, 23)
  722.         
  723.         class BadHash(object):
  724.             fail = False
  725.             
  726.             def __hash__(self):
  727.                 if self.fail:
  728.                     raise Exc()
  729.                 else:
  730.                     return 42
  731.  
  732.  
  733.         d = self._empty_mapping()
  734.         x = BadHash()
  735.         d[x] = 42
  736.         x.fail = True
  737.         self.assertRaises(Exc, d.__getitem__, x)
  738.  
  739.     
  740.     def test_fromkeys(self):
  741.         TestMappingProtocol.test_fromkeys(self)
  742.         
  743.         class mydict(self.type2test):
  744.             
  745.             def __new__(cls):
  746.                 return UserDict.UserDict()
  747.  
  748.  
  749.         ud = mydict.fromkeys('ab')
  750.         self.assertEqual(ud, {
  751.             'a': None,
  752.             'b': None })
  753.         self.assert_(isinstance(ud, UserDict.UserDict))
  754.  
  755.     
  756.     def test_pop(self):
  757.         TestMappingProtocol.test_pop(self)
  758.         
  759.         class Exc(Exception):
  760.             pass
  761.  
  762.         
  763.         class BadHash(object):
  764.             fail = False
  765.             
  766.             def __hash__(self):
  767.                 if self.fail:
  768.                     raise Exc()
  769.                 else:
  770.                     return 42
  771.  
  772.  
  773.         d = self._empty_mapping()
  774.         x = BadHash()
  775.         d[x] = 42
  776.         x.fail = True
  777.         self.assertRaises(Exc, d.pop, x)
  778.  
  779.     
  780.     def test_mutatingiteration(self):
  781.         d = self._empty_mapping()
  782.         d[1] = 1
  783.         
  784.         try:
  785.             for i in d:
  786.                 d[i + 1] = 1
  787.         except RuntimeError:
  788.             pass
  789.  
  790.         self.fail("changing dict size during iteration doesn't raise Error")
  791.  
  792.     
  793.     def test_repr(self):
  794.         d = self._empty_mapping()
  795.         self.assertEqual(repr(d), '{}')
  796.         d[1] = 2
  797.         self.assertEqual(repr(d), '{1: 2}')
  798.         d = self._empty_mapping()
  799.         d[1] = d
  800.         self.assertEqual(repr(d), '{1: {...}}')
  801.         
  802.         class Exc(Exception):
  803.             pass
  804.  
  805.         
  806.         class BadRepr(object):
  807.             
  808.             def __repr__(self):
  809.                 raise Exc()
  810.  
  811.  
  812.         d = self._full_mapping({
  813.             1: BadRepr() })
  814.         self.assertRaises(Exc, repr, d)
  815.  
  816.     
  817.     def test_le(self):
  818.         self.assert_(not (self._empty_mapping() < self._empty_mapping()))
  819.         self.assert_(not (self._full_mapping({
  820.             1: 2 }) < self._full_mapping({
  821.             0x1L: 0x2L })))
  822.         
  823.         class Exc(Exception):
  824.             pass
  825.  
  826.         
  827.         class BadCmp(object):
  828.             
  829.             def __eq__(self, other):
  830.                 raise Exc()
  831.  
  832.  
  833.         d1 = self._full_mapping({
  834.             BadCmp(): 1 })
  835.         d2 = self._full_mapping({
  836.             1: 1 })
  837.         
  838.         try:
  839.             d1 < d2
  840.         except Exc:
  841.             pass
  842.  
  843.         self.fail("< didn't raise Exc")
  844.  
  845.     
  846.     def test_setdefault(self):
  847.         TestMappingProtocol.test_setdefault(self)
  848.         
  849.         class Exc(Exception):
  850.             pass
  851.  
  852.         
  853.         class BadHash(object):
  854.             fail = False
  855.             
  856.             def __hash__(self):
  857.                 if self.fail:
  858.                     raise Exc()
  859.                 else:
  860.                     return 42
  861.  
  862.  
  863.         d = self._empty_mapping()
  864.         x = BadHash()
  865.         d[x] = 42
  866.         x.fail = True
  867.         self.assertRaises(Exc, d.setdefault, x, [])
  868.  
  869.  
  870.